#include <iostream>
#include <string>

using namespace std;

class My_int
{
private:
    int val;
public:
    
    My_int() {this->val = 0;}
    My_int(int val) : val(val) {}
    ~My_int() {}

public:
    void show()
    {
        cout << "val = " << this->val << endl;
    }

public:
    // 成员函数 运算符重载
    // // 运算符重载+
    // const My_int operator+(const My_int & val) const
    // {
    //     int temp = this->val + val.val;
    //     return My_int(temp);
    // }

    // // 运算符重载+
    // const My_int operator+(const int val) const
    // {
    //     int temp = this->val + val;
    //     return My_int(temp);
    // }

    // // 运算符重载-
    // const My_int operator-(const My_int & val) const
    // {
    //     int temp = this->val - val.val;
    //     return My_int(temp);
    // }

    // // 运算符重载-
    // const My_int operator-(const int val) const
    // {
    //     int temp = this->val - val;
    //     return My_int(temp);
    // }

    // // 运算符重载*
    // const My_int operator*(const My_int & val) const
    // {
    //     int temp = this->val * val.val;
    //     return My_int(temp);
    // }

    // // 运算符重载*
    // const My_int operator*(const int val) const
    // {
    //     int temp = this->val * val;
    //     return My_int(temp);
    // }

    // // 运算符重载/
    // const My_int operator/(const My_int & val) const
    // {
    //     int temp = this->val / val.val;
    //     return My_int(temp);
    // }

    // // 运算符重载/
    // const My_int operator/(const int val) const
    // {
    //     int temp = this->val / val;
    //     return My_int(temp);
    // }

    // 友元函数 运算符重载+
    friend const My_int operator+(const My_int & a, const My_int & b);
    friend const My_int operator+(const My_int & a, const int val);

    // 友元函数 运算符重载-
    friend const My_int operator-(const My_int & a, const My_int & b);
    friend const My_int operator-(const My_int & a, const int val);

    // 友元函数 运算符重载*
    friend const My_int operator*(const My_int & a, const My_int & b);
    friend const My_int operator*(const My_int & a, const int val);

    // 友元函数 运算符重载/
    friend const My_int operator/(const My_int & a, const My_int & b);
    friend const My_int operator/(const My_int & a, const int val);
};

// 全局函数 运算符重载
// 运算符重载+
const My_int operator+(const My_int & a, const My_int & b)
{
    int temp = a.val + b.val;
    return My_int(temp);
}

// 运算符重载+
const My_int operator+(const My_int & a, const int val)
{
    int temp = a.val + val;
    return My_int(temp);
}

// 运算符重载-
const My_int operator-(const My_int & a, const My_int & b)
{
    int temp = a.val - b.val;
    return My_int(temp);
}

// 运算符重载-
const My_int operator-(const My_int & a, const int val)
{
    int temp = a.val - val;
    return My_int(temp);
}

// 运算符重载*
const My_int operator*(const My_int & a, const My_int & b)
{
    int temp = a.val * b.val;
    return My_int(temp);
}

// 运算符重载*
const My_int operator*(const My_int & a, const int val)
{
    int temp = a.val * val;
    return My_int(temp);
}

// 运算符重载/
const My_int operator/(const My_int & a, const My_int & b)
{
    int temp = a.val / b.val;
    return My_int(temp);
}

// 运算符重载/
const My_int operator/(const My_int & a, const int val)
{
    int temp = a.val / val;
    return My_int(temp);
}

int main(int argc, char const *argv[])
{
    My_int a(30);
    My_int b(20);
    My_int c(10);

    a.show();
    b.show();
    c.show();

    // 使用运算符重载+
    a = b + 10;
    a.show();

    a = b + c;
    a.show();

    // 使用运算符重载-
    a = b - 10;
    a.show();

    a = b - c;
    a.show();

    // 使用运算符重载*
    a = b * 10;
    a.show();

    a = b * c;
    a.show();

    // 使用运算符重载/
    a = b / 10;
    a.show();

    a = b / c; 
    a.show();
    return 0;
}
